<?php

/**
 * Smarty Internal Plugin Configfileparser
 *
 * This is the config file parser.
 * It is generated from the internal.configfileparser.y file
 *
 * @package    Smarty
 * @subpackage Compiler
 * @author     Uwe Tews
 */
class TPC_yyToken implements ArrayAccess {
	public $string = '';
	public $metadata = array();

	function __construct($s, $m = array()) {
		if ($s instanceof TPC_yyToken)
		{
			$this->string = $s->string;
			$this->metadata = $s->metadata;
		}
		else
		{
			$this->string = (string)$s;
			if ($m instanceof TPC_yyToken)
			{
				$this->metadata = $m->metadata;
			}
			elseif (is_array($m))
			{
				$this->metadata = $m;
			}
		}
	}

	function __toString() {
		return $this->_string;
	}

	function offsetExists($offset) {
		return isset($this->metadata[$offset]);
	}

	function offsetGet($offset) {
		return $this->metadata[$offset];
	}

	function offsetSet($offset, $value) {
		if ($offset === null)
		{
			if (isset($value[0]))
			{
				$x = ($value instanceof TPC_yyToken) ? $value->metadata : $value;
				$this->metadata = array_merge($this->metadata, $x);

				return;
			}
			$offset = count($this->metadata);
		}
		if ($value === null)
		{
			return;
		}
		if ($value instanceof TPC_yyToken)
		{
			if ($value->metadata)
			{
				$this->metadata[$offset] = $value->metadata;
			}
		}
		elseif ($value)
		{
			$this->metadata[$offset] = $value;
		}
	}

	function offsetUnset($offset) {
		unset($this->metadata[$offset]);
	}
}

class TPC_yyStackEntry {
	public $stateno; /* The state-number */
	public $major; /* The major token value.  This is the code
                     ** number for the token at this stack level */
	public $minor; /* The user-supplied minor token value.  This
                     ** is the value of the token  */
}

;


#line 12 "smarty_internal_configfileparser.y"
class Smarty_Internal_Configfileparser #line 79 "smarty_internal_configfileparser.php"
{
	#line 14 "smarty_internal_configfileparser.y"

	// states whether the parse was successful or not
	public $successful = true;
	public $retvalue = 0;
	private $lex;
	private $internalError = false;

	function __construct($lex, $compiler) {
		// set instance object
		self::instance($this);
		$this->lex = $lex;
		$this->smarty = $compiler->smarty;
		$this->compiler = $compiler;
	}

	public static function &instance($new_instance = null) {
		static $instance = null;
		if (isset($new_instance) && is_object($new_instance))
			$instance = $new_instance;

		return $instance;
	}

	private function parse_bool($str) {
		if (in_array(strtolower($str), array('on', 'yes', 'true')))
		{
			$res = true;
		}
		else
		{
			$res = false;
		}

		return $res;
	}

	private static $escapes_single = Array(
			'\\' => '\\',
			'\'' => '\''
	);

	private static function parse_single_quoted_string($qstr) {
		$escaped_string = substr($qstr, 1, strlen($qstr) - 2); //remove outer quotes

		$ss = preg_split('/(\\\\.)/', $escaped_string, -1, PREG_SPLIT_DELIM_CAPTURE);

		$str = "";
		foreach ($ss as $s)
		{
			if (strlen($s) === 2 && $s[0] === '\\')
			{
				if (isset(self::$escapes_single[$s[1]]))
				{
					$s = self::$escapes_single[$s[1]];
				}
			}

			$str .= $s;
		}

		return $str;
	}

	private static function parse_double_quoted_string($qstr) {
		$inner_str = substr($qstr, 1, strlen($qstr) - 2);

		return stripcslashes($inner_str);
	}

	private static function parse_tripple_double_quoted_string($qstr) {
		return stripcslashes($qstr);
	}

	private function set_var(Array $var, Array &$target_array) {
		$key = $var["key"];
		$value = $var["value"];

		if ($this->smarty->config_overwrite || !isset($target_array['vars'][$key]))
		{
			$target_array['vars'][$key] = $value;
		}
		else
		{
			settype($target_array['vars'][$key], 'array');
			$target_array['vars'][$key][] = $value;
		}
	}

	private function add_global_vars(Array $vars) {
		if (!isset($this->compiler->config_data['vars']))
		{
			$this->compiler->config_data['vars'] = Array();
		}
		foreach ($vars as $var)
		{
			$this->set_var($var, $this->compiler->config_data);
		}
	}

	private function add_section_vars($section_name, Array $vars) {
		if (!isset($this->compiler->config_data['sections'][$section_name]['vars']))
		{
			$this->compiler->config_data['sections'][$section_name]['vars'] = Array();
		}
		foreach ($vars as $var)
		{
			$this->set_var($var, $this->compiler->config_data['sections'][$section_name]);
		}
	}

	#line 173 "smarty_internal_configfileparser.php"

	const TPC_OPENB = 1;
	const TPC_SECTION = 2;
	const TPC_CLOSEB = 3;
	const TPC_DOT = 4;
	const TPC_ID = 5;
	const TPC_EQUAL = 6;
	const TPC_FLOAT = 7;
	const TPC_INT = 8;
	const TPC_BOOL = 9;
	const TPC_SINGLE_QUOTED_STRING = 10;
	const TPC_DOUBLE_QUOTED_STRING = 11;
	const TPC_TRIPPLE_QUOTES = 12;
	const TPC_TRIPPLE_TEXT = 13;
	const TPC_TRIPPLE_QUOTES_END = 14;
	const TPC_NAKED_STRING = 15;
	const TPC_OTHER = 16;
	const TPC_NEWLINE = 17;
	const TPC_COMMENTSTART = 18;
	const YY_NO_ACTION = 60;
	const YY_ACCEPT_ACTION = 59;
	const YY_ERROR_ACTION = 58;

	const YY_SZ_ACTTAB = 38;
	static public $yy_action = array(
		/*     0 */
		29,
		30,
		34,
		33,
		24,
		13,
		19,
		25,
		35,
		21,
		/*    10 */
		59,
		8,
		3,
		1,
		20,
		12,
		14,
		31,
		20,
		12,
		/*    20 */
		15,
		17,
		23,
		18,
		27,
		26,
		4,
		5,
		6,
		32,
		/*    30 */
		2,
		11,
		28,
		22,
		16,
		9,
		7,
		10,
	);
	static public $yy_lookahead = array(
		/*     0 */
		7,
		8,
		9,
		10,
		11,
		12,
		5,
		27,
		15,
		16,
		/*    10 */
		20,
		21,
		23,
		23,
		17,
		18,
		13,
		14,
		17,
		18,
		/*    20 */
		15,
		2,
		17,
		4,
		25,
		26,
		6,
		3,
		3,
		14,
		/*    30 */
		23,
		1,
		24,
		17,
		2,
		25,
		22,
		25,
	);
	const YY_SHIFT_USE_DFLT = -8;
	const YY_SHIFT_MAX = 19;
	static public $yy_shift_ofst = array(
		/*     0 */
		-8,
		1,
		1,
		1,
		-7,
		-3,
		-3,
		30,
		-8,
		-8,
		/*    10 */
		-8,
		19,
		5,
		3,
		15,
		16,
		24,
		25,
		32,
		20,
	);
	const YY_REDUCE_USE_DFLT = -21;
	const YY_REDUCE_MAX = 10;
	static public $yy_reduce_ofst = array(
		/*     0 */
		-10,
		-1,
		-1,
		-1,
		-20,
		10,
		12,
		8,
		14,
		7,
		/*    10 */
		-11,
	);
	static public $yyExpectedTokens = array(
		/* 0 */
		array(),
		/* 1 */
		array(5, 17, 18,),
		/* 2 */
		array(5, 17, 18,),
		/* 3 */
		array(5, 17, 18,),
		/* 4 */
		array(7, 8, 9, 10, 11, 12, 15, 16,),
		/* 5 */
		array(17, 18,),
		/* 6 */
		array(17, 18,),
		/* 7 */
		array(1,),
		/* 8 */
		array(),
		/* 9 */
		array(),
		/* 10 */
		array(),
		/* 11 */
		array(2, 4,),
		/* 12 */
		array(15, 17,),
		/* 13 */
		array(13, 14,),
		/* 14 */
		array(14,),
		/* 15 */
		array(17,),
		/* 16 */
		array(3,),
		/* 17 */
		array(3,),
		/* 18 */
		array(2,),
		/* 19 */
		array(6,),
		/* 20 */
		array(),
		/* 21 */
		array(),
		/* 22 */
		array(),
		/* 23 */
		array(),
		/* 24 */
		array(),
		/* 25 */
		array(),
		/* 26 */
		array(),
		/* 27 */
		array(),
		/* 28 */
		array(),
		/* 29 */
		array(),
		/* 30 */
		array(),
		/* 31 */
		array(),
		/* 32 */
		array(),
		/* 33 */
		array(),
		/* 34 */
		array(),
		/* 35 */
		array(),
	);
	static public $yy_default = array(
		/*     0 */
		44,
		37,
		41,
		40,
		58,
		58,
		58,
		36,
		39,
		44,
		/*    10 */
		44,
		58,
		58,
		58,
		58,
		58,
		58,
		58,
		58,
		58,
		/*    20 */
		55,
		54,
		57,
		56,
		50,
		45,
		43,
		42,
		38,
		46,
		/*    30 */
		47,
		52,
		51,
		49,
		48,
		53,
	);
	const YYNOCODE = 29;
	const YYSTACKDEPTH = 100;
	const YYNSTATE = 36;
	const YYNRULE = 22;
	const YYERRORSYMBOL = 19;
	const YYERRSYMDT = 'yy0';
	const YYFALLBACK = 0;
	static public $yyFallback = array();

	static function Trace($TraceFILE, $zTracePrompt) {
		if (!$TraceFILE)
		{
			$zTracePrompt = 0;
		}
		elseif (!$zTracePrompt)
		{
			$TraceFILE = 0;
		}
		self::$yyTraceFILE = $TraceFILE;
		self::$yyTracePrompt = $zTracePrompt;
	}

	static function PrintTrace() {
		self::$yyTraceFILE = fopen('php://output', 'w');
		self::$yyTracePrompt = '<br>';
	}

	static public $yyTraceFILE;
	static public $yyTracePrompt;
	public $yyidx; /* Index of top element in stack */
	public $yyerrcnt; /* Shifts left before out of the error */
	public $yystack = array(); /* The parser's stack */

	public $yyTokenName = array(
			'$',
			'OPENB',
			'SECTION',
			'CLOSEB',
			'DOT',
			'ID',
			'EQUAL',
			'FLOAT',
			'INT',
			'BOOL',
			'SINGLE_QUOTED_STRING',
			'DOUBLE_QUOTED_STRING',
			'TRIPPLE_QUOTES',
			'TRIPPLE_TEXT',
			'TRIPPLE_QUOTES_END',
			'NAKED_STRING',
			'OTHER',
			'NEWLINE',
			'COMMENTSTART',
			'error',
			'start',
			'global_vars',
			'sections',
			'var_list',
			'section',
			'newline',
			'var',
			'value',
	);

	static public $yyRuleName = array(
		/*   0 */
		"start ::= global_vars sections",
		/*   1 */
		"global_vars ::= var_list",
		/*   2 */
		"sections ::= sections section",
		/*   3 */
		"sections ::=",
		/*   4 */
		"section ::= OPENB SECTION CLOSEB newline var_list",
		/*   5 */
		"section ::= OPENB DOT SECTION CLOSEB newline var_list",
		/*   6 */
		"var_list ::= var_list newline",
		/*   7 */
		"var_list ::= var_list var",
		/*   8 */
		"var_list ::=",
		/*   9 */
		"var ::= ID EQUAL value",
		/*  10 */
		"value ::= FLOAT",
		/*  11 */
		"value ::= INT",
		/*  12 */
		"value ::= BOOL",
		/*  13 */
		"value ::= SINGLE_QUOTED_STRING",
		/*  14 */
		"value ::= DOUBLE_QUOTED_STRING",
		/*  15 */
		"value ::= TRIPPLE_QUOTES TRIPPLE_TEXT TRIPPLE_QUOTES_END",
		/*  16 */
		"value ::= TRIPPLE_QUOTES TRIPPLE_QUOTES_END",
		/*  17 */
		"value ::= NAKED_STRING",
		/*  18 */
		"value ::= OTHER",
		/*  19 */
		"newline ::= NEWLINE",
		/*  20 */
		"newline ::= COMMENTSTART NEWLINE",
		/*  21 */
		"newline ::= COMMENTSTART NAKED_STRING NEWLINE",
	);

	function tokenName($tokenType) {
		if ($tokenType === 0)
		{
			return 'End of Input';
		}
		if ($tokenType > 0 && $tokenType < count($this->yyTokenName))
		{
			return $this->yyTokenName[$tokenType];
		}
		else
		{
			return "Unknown";
		}
	}

	static function yy_destructor($yymajor, $yypminor) {
		switch ($yymajor)
		{
			default:
				break; /* If no destructor action specified: do nothing */
		}
	}

	function yy_pop_parser_stack() {
		if (!count($this->yystack))
		{
			return;
		}
		$yytos = array_pop($this->yystack);
		if (self::$yyTraceFILE && $this->yyidx >= 0)
		{
			fwrite(self::$yyTraceFILE, self::$yyTracePrompt . 'Popping ' . $this->yyTokenName[$yytos->major] . "\n");
		}
		$yymajor = $yytos->major;
		self::yy_destructor($yymajor, $yytos->minor);
		$this->yyidx--;

		return $yymajor;
	}

	function __destruct() {
		while ($this->yystack !== Array())
		{
			$this->yy_pop_parser_stack();
		}
		if (is_resource(self::$yyTraceFILE))
		{
			fclose(self::$yyTraceFILE);
		}
	}

	function yy_get_expected_tokens($token) {
		$state = $this->yystack[$this->yyidx]->stateno;
		$expected = self::$yyExpectedTokens[$state];
		if (in_array($token, self::$yyExpectedTokens[$state], true))
		{
			return $expected;
		}
		$stack = $this->yystack;
		$yyidx = $this->yyidx;
		do
		{
			$yyact = $this->yy_find_shift_action($token);
			if ($yyact >= self::YYNSTATE && $yyact < self::YYNSTATE + self::YYNRULE)
			{
				// reduce action
				$done = 0;
				do
				{
					if ($done++ == 100)
					{
						$this->yyidx = $yyidx;
						$this->yystack = $stack;
						// too much recursion prevents proper detection
						// so give up
						return array_unique($expected);
					}
					$yyruleno = $yyact - self::YYNSTATE;
					$this->yyidx -= self::$yyRuleInfo[$yyruleno]['rhs'];
					$nextstate = $this->yy_find_reduce_action($this->yystack[$this->yyidx]->stateno, self::$yyRuleInfo[$yyruleno]['lhs']);
					if (isset(self::$yyExpectedTokens[$nextstate]))
					{
						$expected = array_merge($expected, self::$yyExpectedTokens[$nextstate]);
						if (in_array($token, self::$yyExpectedTokens[$nextstate], true))
						{
							$this->yyidx = $yyidx;
							$this->yystack = $stack;

							return array_unique($expected);
						}
					}
					if ($nextstate < self::YYNSTATE)
					{
						// we need to shift a non-terminal
						$this->yyidx++;
						$x = new TPC_yyStackEntry;
						$x->stateno = $nextstate;
						$x->major = self::$yyRuleInfo[$yyruleno]['lhs'];
						$this->yystack[$this->yyidx] = $x;
						continue 2;
					}
					elseif ($nextstate == self::YYNSTATE + self::YYNRULE + 1)
					{
						$this->yyidx = $yyidx;
						$this->yystack = $stack;
						// the last token was just ignored, we can't accept
						// by ignoring input, this is in essence ignoring a
						// syntax error!
						return array_unique($expected);
					}
					elseif ($nextstate === self::YY_NO_ACTION)
					{
						$this->yyidx = $yyidx;
						$this->yystack = $stack;

						// input accepted, but not shifted (I guess)
						return $expected;
					}
					else
					{
						$yyact = $nextstate;
					}
				} while (true);
			}
			break;
		} while (true);
		$this->yyidx = $yyidx;
		$this->yystack = $stack;

		return array_unique($expected);
	}

	function yy_is_expected_token($token) {
		if ($token === 0)
		{
			return true; // 0 is not part of this
		}
		$state = $this->yystack[$this->yyidx]->stateno;
		if (in_array($token, self::$yyExpectedTokens[$state], true))
		{
			return true;
		}
		$stack = $this->yystack;
		$yyidx = $this->yyidx;
		do
		{
			$yyact = $this->yy_find_shift_action($token);
			if ($yyact >= self::YYNSTATE && $yyact < self::YYNSTATE + self::YYNRULE)
			{
				// reduce action
				$done = 0;
				do
				{
					if ($done++ == 100)
					{
						$this->yyidx = $yyidx;
						$this->yystack = $stack;
						// too much recursion prevents proper detection
						// so give up
						return true;
					}
					$yyruleno = $yyact - self::YYNSTATE;
					$this->yyidx -= self::$yyRuleInfo[$yyruleno]['rhs'];
					$nextstate = $this->yy_find_reduce_action($this->yystack[$this->yyidx]->stateno, self::$yyRuleInfo[$yyruleno]['lhs']);
					if (isset(self::$yyExpectedTokens[$nextstate]) && in_array($token, self::$yyExpectedTokens[$nextstate], true))
					{
						$this->yyidx = $yyidx;
						$this->yystack = $stack;

						return true;
					}
					if ($nextstate < self::YYNSTATE)
					{
						// we need to shift a non-terminal
						$this->yyidx++;
						$x = new TPC_yyStackEntry;
						$x->stateno = $nextstate;
						$x->major = self::$yyRuleInfo[$yyruleno]['lhs'];
						$this->yystack[$this->yyidx] = $x;
						continue 2;
					}
					elseif ($nextstate == self::YYNSTATE + self::YYNRULE + 1)
					{
						$this->yyidx = $yyidx;
						$this->yystack = $stack;
						if (!$token)
						{
							// end of input: this is valid
							return true;
						}
						// the last token was just ignored, we can't accept
						// by ignoring input, this is in essence ignoring a
						// syntax error!
						return false;
					}
					elseif ($nextstate === self::YY_NO_ACTION)
					{
						$this->yyidx = $yyidx;
						$this->yystack = $stack;

						// input accepted, but not shifted (I guess)
						return true;
					}
					else
					{
						$yyact = $nextstate;
					}
				} while (true);
			}
			break;
		} while (true);
		$this->yyidx = $yyidx;
		$this->yystack = $stack;

		return true;
	}

	function yy_find_shift_action($iLookAhead) {
		$stateno = $this->yystack[$this->yyidx]->stateno;

		/* if ($this->yyidx < 0) return self::YY_NO_ACTION;  */
		if (!isset(self::$yy_shift_ofst[$stateno]))
		{
			// no shift actions
			return self::$yy_default[$stateno];
		}
		$i = self::$yy_shift_ofst[$stateno];
		if ($i === self::YY_SHIFT_USE_DFLT)
		{
			return self::$yy_default[$stateno];
		}
		if ($iLookAhead == self::YYNOCODE)
		{
			return self::YY_NO_ACTION;
		}
		$i += $iLookAhead;
		if ($i < 0 || $i >= self::YY_SZ_ACTTAB || self::$yy_lookahead[$i] != $iLookAhead)
		{
			if (count(self::$yyFallback) && $iLookAhead < count(self::$yyFallback) && ($iFallback = self::$yyFallback[$iLookAhead]) != 0)
			{
				if (self::$yyTraceFILE)
				{
					fwrite(self::$yyTraceFILE, self::$yyTracePrompt . "FALLBACK " . $this->yyTokenName[$iLookAhead] . " => " . $this->yyTokenName[$iFallback] . "\n");
				}

				return $this->yy_find_shift_action($iFallback);
			}

			return self::$yy_default[$stateno];
		}
		else
		{
			return self::$yy_action[$i];
		}
	}

	function yy_find_reduce_action($stateno, $iLookAhead) {
		/* $stateno = $this->yystack[$this->yyidx]->stateno; */

		if (!isset(self::$yy_reduce_ofst[$stateno]))
		{
			return self::$yy_default[$stateno];
		}
		$i = self::$yy_reduce_ofst[$stateno];
		if ($i == self::YY_REDUCE_USE_DFLT)
		{
			return self::$yy_default[$stateno];
		}
		if ($iLookAhead == self::YYNOCODE)
		{
			return self::YY_NO_ACTION;
		}
		$i += $iLookAhead;
		if ($i < 0 || $i >= self::YY_SZ_ACTTAB || self::$yy_lookahead[$i] != $iLookAhead)
		{
			return self::$yy_default[$stateno];
		}
		else
		{
			return self::$yy_action[$i];
		}
	}

	function yy_shift($yyNewState, $yyMajor, $yypMinor) {
		$this->yyidx++;
		if ($this->yyidx >= self::YYSTACKDEPTH)
		{
			$this->yyidx--;
			if (self::$yyTraceFILE)
			{
				fprintf(self::$yyTraceFILE, "%sStack Overflow!\n", self::$yyTracePrompt);
			}
			while ($this->yyidx >= 0)
			{
				$this->yy_pop_parser_stack();
			}
			#line 125 "smarty_internal_configfileparser.y"

			$this->internalError = true;
			$this->compiler->trigger_config_file_error("Stack overflow in configfile parser");

			#line 593 "smarty_internal_configfileparser.php"
			return;
		}
		$yytos = new TPC_yyStackEntry;
		$yytos->stateno = $yyNewState;
		$yytos->major = $yyMajor;
		$yytos->minor = $yypMinor;
		array_push($this->yystack, $yytos);
		if (self::$yyTraceFILE && $this->yyidx > 0)
		{
			fprintf(self::$yyTraceFILE, "%sShift %d\n", self::$yyTracePrompt, $yyNewState);
			fprintf(self::$yyTraceFILE, "%sStack:", self::$yyTracePrompt);
			for ($i = 1; $i <= $this->yyidx; $i++)
			{
				fprintf(self::$yyTraceFILE, " %s", $this->yyTokenName[$this->yystack[$i]->major]);
			}
			fwrite(self::$yyTraceFILE, "\n");
		}
	}

	static public $yyRuleInfo = array(
			array('lhs' => 20, 'rhs' => 2),
			array('lhs' => 21, 'rhs' => 1),
			array('lhs' => 22, 'rhs' => 2),
			array('lhs' => 22, 'rhs' => 0),
			array('lhs' => 24, 'rhs' => 5),
			array('lhs' => 24, 'rhs' => 6),
			array('lhs' => 23, 'rhs' => 2),
			array('lhs' => 23, 'rhs' => 2),
			array('lhs' => 23, 'rhs' => 0),
			array('lhs' => 26, 'rhs' => 3),
			array('lhs' => 27, 'rhs' => 1),
			array('lhs' => 27, 'rhs' => 1),
			array('lhs' => 27, 'rhs' => 1),
			array('lhs' => 27, 'rhs' => 1),
			array('lhs' => 27, 'rhs' => 1),
			array('lhs' => 27, 'rhs' => 3),
			array('lhs' => 27, 'rhs' => 2),
			array('lhs' => 27, 'rhs' => 1),
			array('lhs' => 27, 'rhs' => 1),
			array('lhs' => 25, 'rhs' => 1),
			array('lhs' => 25, 'rhs' => 2),
			array('lhs' => 25, 'rhs' => 3),
	);

	static public $yyReduceMap = array(
			0 => 0,
			2 => 0,
			3 => 0,
			19 => 0,
			20 => 0,
			21 => 0,
			1 => 1,
			4 => 4,
			5 => 5,
			6 => 6,
			7 => 7,
			8 => 8,
			9 => 9,
			10 => 10,
			11 => 11,
			12 => 12,
			13 => 13,
			14 => 14,
			15 => 15,
			16 => 16,
			17 => 17,
			18 => 17,
	);

	#line 131 "smarty_internal_configfileparser.y"
	function yy_r0() {
		$this->_retvalue = null;
	}

	#line 666 "smarty_internal_configfileparser.php"
	#line 136 "smarty_internal_configfileparser.y"
	function yy_r1() {
		$this->add_global_vars($this->yystack[$this->yyidx + 0]->minor);
		$this->_retvalue = null;
	}

	#line 671 "smarty_internal_configfileparser.php"
	#line 149 "smarty_internal_configfileparser.y"
	function yy_r4() {
		$this->add_section_vars($this->yystack[$this->yyidx + -3]->minor, $this->yystack[$this->yyidx + 0]->minor);
		$this->_retvalue = null;
	}

	#line 677 "smarty_internal_configfileparser.php"
	#line 154 "smarty_internal_configfileparser.y"
	function yy_r5() {
		if ($this->smarty->config_read_hidden)
		{
			$this->add_section_vars($this->yystack[$this->yyidx + -3]->minor, $this->yystack[$this->yyidx + 0]->minor);
		}
		$this->_retvalue = null;
	}

	#line 685 "smarty_internal_configfileparser.php"
	#line 162 "smarty_internal_configfileparser.y"
	function yy_r6() {
		$this->_retvalue = $this->yystack[$this->yyidx + -1]->minor;
	}

	#line 690 "smarty_internal_configfileparser.php"
	#line 166 "smarty_internal_configfileparser.y"
	function yy_r7() {
		$this->_retvalue = array_merge($this->yystack[$this->yyidx + -1]->minor, Array($this->yystack[$this->yyidx + 0]->minor));
	}

	#line 695 "smarty_internal_configfileparser.php"
	#line 170 "smarty_internal_configfileparser.y"
	function yy_r8() {
		$this->_retvalue = Array();
	}

	#line 700 "smarty_internal_configfileparser.php"
	#line 176 "smarty_internal_configfileparser.y"
	function yy_r9() {
		$this->_retvalue = Array("key" => $this->yystack[$this->yyidx + -2]->minor, "value" => $this->yystack[$this->yyidx + 0]->minor);
	}

	#line 705 "smarty_internal_configfileparser.php"
	#line 181 "smarty_internal_configfileparser.y"
	function yy_r10() {
		$this->_retvalue = (float)$this->yystack[$this->yyidx + 0]->minor;
	}

	#line 710 "smarty_internal_configfileparser.php"
	#line 185 "smarty_internal_configfileparser.y"
	function yy_r11() {
		$this->_retvalue = (int)$this->yystack[$this->yyidx + 0]->minor;
	}

	#line 715 "smarty_internal_configfileparser.php"
	#line 189 "smarty_internal_configfileparser.y"
	function yy_r12() {
		$this->_retvalue = $this->parse_bool($this->yystack[$this->yyidx + 0]->minor);
	}

	#line 720 "smarty_internal_configfileparser.php"
	#line 193 "smarty_internal_configfileparser.y"
	function yy_r13() {
		$this->_retvalue = self::parse_single_quoted_string($this->yystack[$this->yyidx + 0]->minor);
	}

	#line 725 "smarty_internal_configfileparser.php"
	#line 197 "smarty_internal_configfileparser.y"
	function yy_r14() {
		$this->_retvalue = self::parse_double_quoted_string($this->yystack[$this->yyidx + 0]->minor);
	}

	#line 730 "smarty_internal_configfileparser.php"
	#line 201 "smarty_internal_configfileparser.y"
	function yy_r15() {
		$this->_retvalue = self::parse_tripple_double_quoted_string($this->yystack[$this->yyidx + -1]->minor);
	}

	#line 735 "smarty_internal_configfileparser.php"
	#line 205 "smarty_internal_configfileparser.y"
	function yy_r16() {
		$this->_retvalue = '';
	}

	#line 740 "smarty_internal_configfileparser.php"
	#line 209 "smarty_internal_configfileparser.y"
	function yy_r17() {
		$this->_retvalue = $this->yystack[$this->yyidx + 0]->minor;
	}

	#line 745 "smarty_internal_configfileparser.php"

	private $_retvalue;

	function yy_reduce($yyruleno) {
		$yymsp = $this->yystack[$this->yyidx];
		if (self::$yyTraceFILE && $yyruleno >= 0 && $yyruleno < count(self::$yyRuleName))
		{
			fprintf(self::$yyTraceFILE, "%sReduce (%d) [%s].\n", self::$yyTracePrompt, $yyruleno, self::$yyRuleName[$yyruleno]);
		}

		$this->_retvalue = $yy_lefthand_side = null;
		if (array_key_exists($yyruleno, self::$yyReduceMap))
		{
			// call the action
			$this->_retvalue = null;
			$this->{'yy_r' . self::$yyReduceMap[$yyruleno]}();
			$yy_lefthand_side = $this->_retvalue;
		}
		$yygoto = self::$yyRuleInfo[$yyruleno]['lhs'];
		$yysize = self::$yyRuleInfo[$yyruleno]['rhs'];
		$this->yyidx -= $yysize;
		for ($i = $yysize; $i; $i--)
		{
			// pop all of the right-hand side parameters
			array_pop($this->yystack);
		}
		$yyact = $this->yy_find_reduce_action($this->yystack[$this->yyidx]->stateno, $yygoto);
		if ($yyact < self::YYNSTATE)
		{
			if (!self::$yyTraceFILE && $yysize)
			{
				$this->yyidx++;
				$x = new TPC_yyStackEntry;
				$x->stateno = $yyact;
				$x->major = $yygoto;
				$x->minor = $yy_lefthand_side;
				$this->yystack[$this->yyidx] = $x;
			}
			else
			{
				$this->yy_shift($yyact, $yygoto, $yy_lefthand_side);
			}
		}
		elseif ($yyact == self::YYNSTATE + self::YYNRULE + 1)
		{
			$this->yy_accept();
		}
	}

	function yy_parse_failed() {
		if (self::$yyTraceFILE)
		{
			fprintf(self::$yyTraceFILE, "%sFail!\n", self::$yyTracePrompt);
		}
		while ($this->yyidx >= 0)
		{
			$this->yy_pop_parser_stack();
		}
	}

	function yy_syntax_error($yymajor, $TOKEN) {
		#line 118 "smarty_internal_configfileparser.y"

		$this->internalError = true;
		$this->yymajor = $yymajor;
		$this->compiler->trigger_config_file_error();
		#line 808 "smarty_internal_configfileparser.php"
	}

	function yy_accept() {
		if (self::$yyTraceFILE)
		{
			fprintf(self::$yyTraceFILE, "%sAccept!\n", self::$yyTracePrompt);
		}
		while ($this->yyidx >= 0)
		{
			$stack = $this->yy_pop_parser_stack();
		}
		#line 110 "smarty_internal_configfileparser.y"

		$this->successful = !$this->internalError;
		$this->internalError = false;
		$this->retvalue = $this->_retvalue;
		//echo $this->retvalue."\n\n";
		#line 826 "smarty_internal_configfileparser.php"
	}

	function doParse($yymajor, $yytokenvalue) {
		$yyerrorhit = 0; /* True if yymajor has invoked an error */

		if ($this->yyidx === null || $this->yyidx < 0)
		{
			$this->yyidx = 0;
			$this->yyerrcnt = -1;
			$x = new TPC_yyStackEntry;
			$x->stateno = 0;
			$x->major = 0;
			$this->yystack = array();
			array_push($this->yystack, $x);
		}
		$yyendofinput = ($yymajor == 0);

		if (self::$yyTraceFILE)
		{
			fprintf(self::$yyTraceFILE, "%sInput %s\n", self::$yyTracePrompt, $this->yyTokenName[$yymajor]);
		}

		do
		{
			$yyact = $this->yy_find_shift_action($yymajor);
			if ($yymajor < self::YYERRORSYMBOL && !$this->yy_is_expected_token($yymajor))
			{
				// force a syntax error
				$yyact = self::YY_ERROR_ACTION;
			}
			if ($yyact < self::YYNSTATE)
			{
				$this->yy_shift($yyact, $yymajor, $yytokenvalue);
				$this->yyerrcnt--;
				if ($yyendofinput && $this->yyidx >= 0)
				{
					$yymajor = 0;
				}
				else
				{
					$yymajor = self::YYNOCODE;
				}
			}
			elseif ($yyact < self::YYNSTATE + self::YYNRULE)
			{
				$this->yy_reduce($yyact - self::YYNSTATE);
			}
			elseif ($yyact == self::YY_ERROR_ACTION)
			{
				if (self::$yyTraceFILE)
				{
					fprintf(self::$yyTraceFILE, "%sSyntax Error!\n", self::$yyTracePrompt);
				}
				if (self::YYERRORSYMBOL)
				{
					if ($this->yyerrcnt < 0)
					{
						$this->yy_syntax_error($yymajor, $yytokenvalue);
					}
					$yymx = $this->yystack[$this->yyidx]->major;
					if ($yymx == self::YYERRORSYMBOL || $yyerrorhit)
					{
						if (self::$yyTraceFILE)
						{
							fprintf(self::$yyTraceFILE, "%sDiscard input token %s\n", self::$yyTracePrompt, $this->yyTokenName[$yymajor]);
						}
						$this->yy_destructor($yymajor, $yytokenvalue);
						$yymajor = self::YYNOCODE;
					}
					else
					{
						while ($this->yyidx >= 0 && $yymx != self::YYERRORSYMBOL && ($yyact = $this->yy_find_shift_action(self::YYERRORSYMBOL)) >= self::YYNSTATE)
						{
							$this->yy_pop_parser_stack();
						}
						if ($this->yyidx < 0 || $yymajor == 0)
						{
							$this->yy_destructor($yymajor, $yytokenvalue);
							$this->yy_parse_failed();
							$yymajor = self::YYNOCODE;
						}
						elseif ($yymx != self::YYERRORSYMBOL)
						{
							$u2 = 0;
							$this->yy_shift($yyact, self::YYERRORSYMBOL, $u2);
						}
					}
					$this->yyerrcnt = 3;
					$yyerrorhit = 1;
				}
				else
				{
					if ($this->yyerrcnt <= 0)
					{
						$this->yy_syntax_error($yymajor, $yytokenvalue);
					}
					$this->yyerrcnt = 3;
					$this->yy_destructor($yymajor, $yytokenvalue);
					if ($yyendofinput)
					{
						$this->yy_parse_failed();
					}
					$yymajor = self::YYNOCODE;
				}
			}
			else
			{
				$this->yy_accept();
				$yymajor = self::YYNOCODE;
			}
		} while ($yymajor != self::YYNOCODE && $this->yyidx >= 0);
	}
}

?>
